package qc.module.ehs.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.enums.EhsTaskCategoryTypeEnum;
import qc.common.core.exception.QCPromptException;
import qc.common.core.utils.DateUtil;
import qc.module.ehs.dto.report.EhsReportQueryConditionDto;
import qc.module.ehs.dto.taskitem.TaskItemInfoDto;
import qc.module.ehs.dto.troublecorrect.EhsTroubleCorrectInfoDto;
import qc.module.ehs.entity.EhsTaskItem;
import qc.module.ehs.entity.EhsTroubleCorrect;
import qc.module.ehs.mapper.EhsTaskItemMapper;
import qc.module.ehs.mapper.EhsTroubleCorrectMapper;
import qc.module.ehs.repository.EhsTaskItemRepository;
import qc.module.ehs.repository.EhsTroubleCorrectRepository;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * EHS报告Service
 *
 * @author QuCheng Tech
 * @since 2025/3/17
 */
@Service
public class EhsReportService {
    @Autowired
    private EhsTaskItemRepository taskItemRepository;

    @Autowired
    private EhsTroubleCorrectRepository troubleCorrectRepository;

    /***
     * 查询安全检查工作任务项
     *
     * @param condition 查询条件
     * @return java.util.List<qc.module.ehs.dto.taskitem.TaskItemInfoDto>
     * @author QuCheng Tech
     * @since 2025/3/17
     */
    public List<TaskItemInfoDto> queryInspection(EhsReportQueryConditionDto condition) throws QCPromptException {
        if (condition == null)
            throw new QCPromptException("查询安全生产检查工作的条件对象不能为空");
        if (StringUtils.isBlank(condition.getOrgcode()))
            throw new QCPromptException("查询安全生产检查工作的条件中组织代码不能为空");
        //判断和转换查询条件中的起止时间
        if (StringUtils.isBlank(condition.getBegintm()))
            throw new QCPromptException("查询安全生产检查工作的起始时间不能为空");
        if (StringUtils.isBlank(condition.getEndtm()))
            throw new QCPromptException("查询安全生产检查工作的截止时间不能为空");

        //查询时间处理
        Date beginDate = null;
        Date endDate = null;
        if (StringUtils.isNotBlank(condition.getBegintm())) {
            try {
                beginDate = DateUtil.parseDate(condition.getBegintm());
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("查询安全生产检查工作的开始日期转换错误");
            }
        }
        if (StringUtils.isNotBlank(condition.getEndtm())) {
            try {
                endDate = DateUtil.parseDate(condition.getEndtm());
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("查询安全生产检查工作的截止日期转换错误");
            }
        }
        if (beginDate == null)
            throw new QCPromptException("查询安全生产检查工作的开始日期不能为空");
        if (endDate == null)
            throw new QCPromptException("查询安全生产检查工作的截止日期不能为空");
        if (beginDate.after(endDate))
            throw new QCPromptException("查询安全生产检查工作的开始日期不能大于截止日期");
        //查询的任务大类，可以为1个或者多个
        List<EhsTaskCategoryTypeEnum> taskCategoryTypes = new ArrayList<>();
        if (condition.getCategory() > 0x0) {
            for (EhsTaskCategoryTypeEnum item : EhsTaskCategoryTypeEnum.values()) {
                if ((condition.getCategory() & item.getIndex()) == item.getIndex()) {
                    taskCategoryTypes.add(item);
                }
            }
        }

        LambdaQueryWrapper<EhsTaskItem> wrapper = new LambdaQueryWrapper<>();
        //组织机构代码，必须有，判断相等
        wrapper.eq(EhsTaskItem::getOrgcode, condition.getOrgcode());
         /*任务项的时间条件判断需要考虑以下几种不同情况：
            1.查询的起止时间前后都包含计划时间，查询时间段包含整个计划时间段；
            pbtm>=tm1 and petm<=tm2
            2.查询的起止时间前后都被计划时间包含，查询的时间段是计划时间段中间的部分时间；
            pbtm<=tm1 and petm>=tm2
            3.查询的起始时间被计划时间包含，查询时间段包含计划时间中的前部分时间；
            查询的截止时间被计划时间包含，查询时间段包含计划时间中的后部分时间；
            pbtm<=tm2 and petm>=tm1
        */
        Date finalBeginDate = beginDate;
        Date finalEndDate = endDate;
        wrapper.and(q -> {
            (q.ge(EhsTaskItem::getPlanbegintm, finalBeginDate).le(EhsTaskItem::getPlanendtm, finalEndDate)).or()
                    .le(EhsTaskItem::getPlanbegintm, finalBeginDate).ge(EhsTaskItem::getPlanendtm, finalEndDate).or()
                    .le(EhsTaskItem::getPlanbegintm, finalEndDate).ge(EhsTaskItem::getPlanendtm, finalBeginDate);
        });
        //查询任务大类；如果没有指定任务大类查询所有任务大类
        if (taskCategoryTypes != null && taskCategoryTypes.size() > 0x0) {
            if (taskCategoryTypes.size() > 0x1) {
                //有多个任务大类
                wrapper.in(EhsTaskItem::getTasktype, taskCategoryTypes);
            } else {
                //只有1个任务大类
                wrapper.eq(EhsTaskItem::getTasktype, taskCategoryTypes.get(0x0));
            }
        }
        //判断是否指定单元ID
        if (StringUtils.isNotBlank(condition.getUnitid()))
            wrapper.eq(EhsTaskItem::getUnitid, condition.getUnitid());
        //判断是否指定责任部门ID
        if (condition.getDeptid() > 0x0)
            wrapper.and(q -> {//判断责任部门ID或者当前责任部门ID
                q.eq(EhsTaskItem::getResdeptid, condition.getDeptid()).or().eq(EhsTaskItem::getTransdeptid, condition.getDeptid());
            });
        //判断是否指定负责人ID
        if (condition.getUserid() > 0x0)
            wrapper.and(q -> {//判断参与组员1、2的ID或者当前责任人ID
                q.eq(EhsTaskItem::getResuserid1, condition.getUserid()).or()
                        .eq(EhsTaskItem::getResuserid2, condition.getUserid()).or()
                        .eq(EhsTaskItem::getTransuserid, condition.getUserid());
            });
        //判断是否有标题文字，在任务项名称中进行模糊匹配
        if (StringUtils.isNotBlank(condition.getTitle()))
            wrapper.like(EhsTaskItem::getItemname, condition.getTitle());

        //按计划开始时间升序、截止时间升序
        wrapper.orderByAsc(EhsTaskItem::getPlanbegintm).orderByAsc(EhsTaskItem::getPlanendtm);

        List<EhsTaskItem> ens = taskItemRepository.selectList(wrapper);
        if (ens != null && ens.size() > 0x0)
            return EhsTaskItemMapper.MAPPER.toDtoList(ens);

        return null;
    }

    /***
     * 查询隐患治理工作
     *
     * @param condition 查询条件
     * @return java.util.List<qc.module.ehs.dto.troublecorrect.EhsTroubleCorrectInfoDto>
     * @author QuCheng Tech
     * @since 2025/3/17
     */
    public List<EhsTroubleCorrectInfoDto> queryTroubleCorrect(EhsReportQueryConditionDto condition) throws QCPromptException {
        if (condition == null)
            throw new QCPromptException("查询隐患治理工作的条件对象不能为空");
        if (StringUtils.isBlank(condition.getOrgcode()))
            throw new QCPromptException("查询隐患治理工作的条件中组织代码不能为空");
        //判断和转换查询条件中的起止时间
        if (StringUtils.isBlank(condition.getBegintm()))
            throw new QCPromptException("查询隐患治理工作的起始时间不能为空");
        if (StringUtils.isBlank(condition.getEndtm()))
            throw new QCPromptException("查询隐患治理工作的截止时间不能为空");

        //查询时间处理
        Date beginDate = null;
        Date endDate = null;
        if (StringUtils.isNotBlank(condition.getBegintm())) {
            try {
                beginDate = DateUtil.parseDate(condition.getBegintm());
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("查询隐患治理工作的开始日期转换错误");
            }
        }
        if (StringUtils.isNotBlank(condition.getEndtm())) {
            try {
                endDate = DateUtil.parseDate(condition.getEndtm());
            } catch (Exception e) {
                // 时间转换错误，抛出自定义异常
                throw new QCPromptException("查询隐患治理工作的截止日期转换错误");
            }
        }
        if (beginDate == null)
            throw new QCPromptException("查询隐患治理工作的开始日期不能为空");
        if (endDate == null)
            throw new QCPromptException("查询隐患治理工作的截止日期不能为空");
        if (beginDate.after(endDate))
            throw new QCPromptException("查询隐患治理工作的开始日期不能大于截止日期");

        LambdaQueryWrapper<EhsTroubleCorrect> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsTroubleCorrect::getOrgcode, condition.getOrgcode());
        Date finalBeginDate = beginDate;
        Date finalEndDate = endDate;
        wrapper.and(q -> {
            q.ge(EhsTroubleCorrect::getTm, finalBeginDate).le(EhsTroubleCorrect::getTm, finalEndDate);
        });
        //判断是否指定单元ID
        if (StringUtils.isNotBlank(condition.getUnitid()))
            wrapper.eq(EhsTroubleCorrect::getUnitid, condition.getUnitid());
        //判断是否指定责任部门ID
        if (condition.getDeptid() > 0x0)
            wrapper.eq(EhsTroubleCorrect::getResdeptid, condition.getDeptid());
        //判断是否指定负责人ID
        if (condition.getUserid() > 0x0)
            wrapper.eq(EhsTroubleCorrect::getResuserid, condition.getUserid());
        //判断是否有标题文字，在任务项名称中进行模糊匹配
        if (StringUtils.isNotBlank(condition.getTitle()))
            wrapper.like(EhsTroubleCorrect::getTitle, condition.getTitle());

        //按发现时间升序
        wrapper.orderByAsc(EhsTroubleCorrect::getTm);

        //3.查询隐患治理记录
        List<EhsTroubleCorrect> ens = troubleCorrectRepository.selectList(wrapper);
        if (ens != null && ens.size() > 0x0)
            return EhsTroubleCorrectMapper.MAPPER.toDtoList(ens);

        return null;
    }
}
